const fs = require("fs");
const path = require("path");
const validator = require("email-validator");
const XLSX = require("xlsx");

// 基础严格验证（同步）
function isValidEmailBasic(email) {
  // === 首先进行大写字母检查 ===
  // 过滤包含任何大写字母的邮箱
  if (email !== email.toLowerCase()) {
    return false;
  }

  // 基本格式检查
  const emailRegex =
    /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;

  if (!emailRegex.test(email)) {
    return false;
  }

  // 检查邮箱是否以@开头（没有本地部分）
  if (email.startsWith("@")) {
    return false;
  }

  // 检查邮箱格式
  const atCount = (email.match(/@/g) || []).length;
  if (atCount !== 1) {
    return false;
  }

  const [localPart, domain] = email.split("@");

  // === 本地部分严格验证 ===

  // 本地部分不能为空
  if (!localPart || localPart.length === 0) {
    return false;
  }

  // 本地部分至少3个字符，最多20个字符（更严格）
  if (localPart.length < 3 || localPart.length > 20) {
    return false;
  }

  // 本地部分不能包含点
  if (localPart.includes(".")) {
    return false;
  }

  // 本地部分不能以数字开头
  if (localPart.match(/^[0-9]/)) {
    return false;
  }

  // 本地部分不能是纯数字
  if (localPart.match(/^[0-9]+$/)) {
    return false;
  }

  // 本地部分不能以特殊字符开头或结尾
  if (localPart.match(/^[^a-zA-Z0-9]/) || localPart.match(/[^a-zA-Z0-9]$/)) {
    return false;
  }

  // 检查连续相同字符（超过2个）
  if (localPart.match(/(.)\1{2,}/)) {
    return false;
  }

  // 检查键盘顺序模式
  const keyboardPatterns = [
    "qwerty",
    "asdf",
    "zxcv",
    "qaz",
    "wsx",
    "edc",
    "123456",
    "654321",
    "abcdef",
    "fedcba",
  ];

  for (const pattern of keyboardPatterns) {
    if (localPart.includes(pattern)) {
      return false;
    }
  }

  // 检查重复模式（如 abcabc、123123）
  const halfLength = Math.floor(localPart.length / 2);
  if (halfLength >= 2) {
    const firstHalf = localPart.substring(0, halfLength);
    const secondHalf = localPart.substring(halfLength, halfLength * 2);
    if (firstHalf === secondHalf) {
      return false;
    }
  }

  // === 域名部分严格验证 ===

  // 域名不能为空
  if (!domain || domain.length === 0) {
    return false;
  }

  // 域名不能超过253个字符
  if (domain.length > 253) {
    return false;
  }

  // 扩展过滤域名列表（包括更多中国和免费邮箱服务商）
  const excludedDomains = [
    "qq.com",
    "163.com",
    "126.com",
    "139.com",
    "sina.com",
    "sohu.com",
    "foxmail.com",
    "yeah.net",
    "tom.com",
    "vip.sina.com",
    "vip.163.com",
    "vip.126.com",
    "21cn.com",
    "188.com",
    "wo.com.cn",
    "aliyun.com",
    "taobao.com",
    "tmall.com",
    "alibaba.com",
    "wangyi.com",
    "netease.com",
    // 免费邮箱服务
    "10minutemail.com",
    "guerrillamail.com",
    "tempmail.org",
    "mailinator.com",
    "yopmail.com",
    "temp-mail.org",
    // 其他可疑域名
    "test.com",
    "example.com",
    "sample.com",
    "demo.com",
  ];

  if (excludedDomains.includes(domain.toLowerCase())) {
    return false;
  }

  // 检查域名格式
  const domainParts = domain.split(".");
  if (domainParts.length < 2) {
    return false;
  }

  // 每个域名部分的严格检查
  for (let i = 0; i < domainParts.length; i++) {
    const part = domainParts[i];

    // 域名部分不能为空
    if (part.length === 0) {
      return false;
    }

    // 域名部分至少2个字符
    if (part.length < 2) {
      return false;
    }

    // 域名部分不能以-开头或结尾
    if (part.startsWith("-") || part.endsWith("-")) {
      return false;
    }

    // 域名部分只能包含字母、数字和连字符
    if (!part.match(/^[a-zA-Z0-9-]+$/)) {
      return false;
    }
  }

  // 顶级域名严格检查
  const tld = domainParts[domainParts.length - 1];

  // 顶级域名至少2个字符且不超过4个字符（更严格）
  if (tld.length < 2 || tld.length > 4) {
    return false;
  }

  // 顶级域名只能包含字母
  if (!tld.match(/^[a-zA-Z]+$/)) {
    return false;
  }

  // 更严格的顶级域名白名单（只保留最常见的）
  const validTlds = ["com", "org", "net", "edu", "gov", "co", "io", "me"];

  if (!validTlds.includes(tld.toLowerCase())) {
    return false;
  }

  // 二级域名检查
  if (domainParts.length >= 2) {
    const secondLevel = domainParts[domainParts.length - 2];

    // 二级域名至少3个字符（更严格）
    if (secondLevel.length < 3) {
      return false;
    }

    // 过滤明显的假域名模式
    const suspiciousDomainPatterns = [
      /^[0-9]+$/, // 纯数字域名
      /^[a-z]$/, // 单字母域名
      /^test$/, // test域名
      /^demo$/, // demo域名
      /^sample$/, // sample域名
    ];

    for (const pattern of suspiciousDomainPatterns) {
      if (pattern.test(secondLevel)) {
        return false;
      }
    }

    // 检查二级域名是否包含连续相同字符
    if (secondLevel.match(/(.)\1{2,}/)) {
      return false;
    }
  }

  // === 额外的严格检查 ===

  // 本地部分必须包含至少一个字母
  if (!localPart.match(/[a-z]/)) {
    return false;
  }

  // 检查本地部分是否有过多的特殊字符
  const specialCharCount = (localPart.match(/[^a-zA-Z0-9]/g) || []).length;
  if (specialCharCount > 1) {
    return false;
  }

  // 检查是否有连续的特殊字符
  if (localPart.match(/[^a-zA-Z0-9]{2,}/)) {
    return false;
  }

  // 检查整个邮箱长度
  if (email.length > 50) {
    // 更严格的长度限制
    return false;
  }

  // 过滤常见的垃圾邮箱模式
  const spamPatterns = [
    /^admin/,
    /^test/,
    /^demo/,
    /^sample/,
    /^temp/,
    /^no.*reply/,
    /^support/,
    /^info/,
    /^contact/,
    /^help/,
    /^service/,
    /^mail/,
  ];

  for (const pattern of spamPatterns) {
    if (pattern.test(localPart)) {
      return false;
    }
  }

  return true;
}

// 深度邮箱验证（异步）
async function isValidEmailDeep(email) {
  // 首先进行基础验证
  if (!isValidEmailBasic(email)) {
    return false;
  }

  try {
    console.log(`深度验证邮箱: ${email}`);

    // 使用 email-validator 进行基本验证
    const isValidSyntax = validator.validate(email);

    if (!isValidSyntax) {
      console.log(`  - 语法验证失败`);
      return false;
    }

    console.log(`  - 验证通过`);
    return true;
  } catch (error) {
    console.log(`  - 验证出错: ${error.message}`);
    return false;
  }
}

async function processEmailFile() {
  try {
    const inputFile = "流失用户.json";
    const outputFile = "有效邮箱分组.xlsx";
    const basicValidFile = "基础验证通过.txt";

    // 检查输入文件是否存在
    if (!fs.existsSync(inputFile)) {
      console.error(`错误: 找不到文件 "${inputFile}"`);
      return;
    }

    // 读取JSON文件内容
    const content = fs.readFileSync(inputFile, "utf-8");
    console.log(`读取文件: ${inputFile}`);

    let jsonData;
    try {
      jsonData = JSON.parse(content);
    } catch (parseError) {
      console.error(`JSON解析错误: ${parseError.message}`);
      return;
    }

    if (!Array.isArray(jsonData)) {
      console.error("错误: JSON数据不是数组格式");
      return;
    }

    console.log(`总记录数: ${jsonData.length}`);

    // 提取邮箱和商品信息
    const emailGoodsMap = [];
    const invalidEntries = [];

    for (const entry of jsonData) {
      if (entry.user_email && entry.goods_name) {
        let email = entry.user_email.trim();

        // 去除前后的双引号
        if (email.startsWith('"') && email.endsWith('"')) {
          email = email.slice(1, -1);
        }

        emailGoodsMap.push({
          email: email,
          goodsName: entry.goods_name.trim(),
        });
      } else {
        invalidEntries.push(entry);
      }
    }

    console.log(`有效记录数: ${emailGoodsMap.length}`);
    console.log(`无效记录数: ${invalidEntries.length}`);

    // 第一步：基础严格验证
    console.log("\n=== 第一步：基础严格验证 ===");
    const basicValidEmails = [];
    const basicInvalidEmails = [];

    for (const item of emailGoodsMap) {
      if (isValidEmailBasic(item.email)) {
        basicValidEmails.push(item);
      } else {
        basicInvalidEmails.push(item);
      }
    }

    console.log(`基础验证通过: ${basicValidEmails.length}`);
    console.log(`基础验证失败: ${basicInvalidEmails.length}`);

    // 去重基础验证通过的邮箱（按邮箱+商品名组合去重）
    const uniqueBasicEmails = [];
    const seen = new Set();

    for (const item of basicValidEmails) {
      const key = `${item.email}_${item.goodsName}`;
      if (!seen.has(key)) {
        seen.add(key);
        uniqueBasicEmails.push(item);
      }
    }

    console.log(`去重后基础验证通过: ${uniqueBasicEmails.length}`);

    // 保存基础验证通过的邮箱（仅邮箱地址）
    if (uniqueBasicEmails.length > 0) {
      const basicEmails = uniqueBasicEmails.map((item) => item.email);
      fs.writeFileSync(basicValidFile, basicEmails.join("\n") + "\n", "utf-8");
      console.log(`基础验证通过的邮箱已保存到: ${basicValidFile}`);
    }

    // 第二步：深度验证
    console.log("\n=== 第二步：深度验证 ===");
    const finalValidEmails = [];
    const deepInvalidEmails = [];

    console.log(`开始深度验证 ${uniqueBasicEmails.length} 个邮箱...`);

    for (let i = 0; i < uniqueBasicEmails.length; i++) {
      const item = uniqueBasicEmails[i];
      console.log(`\n进度: ${i + 1}/${uniqueBasicEmails.length}`);

      const isValid = await isValidEmailDeep(item.email);

      if (isValid) {
        finalValidEmails.push(item);
      } else {
        deepInvalidEmails.push(item);
      }
    }

    // 按商品名分组
    console.log("\n=== 按商品名分组并创建Excel文件 ===");
    const groupedByGoods = {};

    for (const item of finalValidEmails) {
      if (!groupedByGoods[item.goodsName]) {
        groupedByGoods[item.goodsName] = [];
      }
      groupedByGoods[item.goodsName].push(item.email);
    }

    // 按邮箱数量从多到少排序
    const sortedGoodsNames = Object.keys(groupedByGoods).sort((a, b) => {
      return groupedByGoods[b].length - groupedByGoods[a].length;
    });

    console.log(`商品类型数量: ${sortedGoodsNames.length}`);

    // 创建Excel工作簿
    const workbook = XLSX.utils.book_new();
    const usedSheetNames = new Set(); // 用于跟踪已使用的工作表名称

    // 为每个商品创建一个工作表（按邮箱数量排序）
    for (const goodsName of sortedGoodsNames) {
      const emails = groupedByGoods[goodsName];

      // 将邮箱数据转换为工作表格式
      const worksheetData = [
        ["邮箱地址"], // 表头
        ...emails.map((email) => [email]), // 每行一个邮箱
      ];

      // 创建工作表
      const worksheet = XLSX.utils.aoa_to_sheet(worksheetData);

      // 设置列宽
      worksheet["!cols"] = [{ wch: 30 }]; // 邮箱列宽度为30个字符

      // 清理sheet名称中的特殊字符（Excel sheet名称不能包含某些字符）
      let safeSheetName = goodsName.replace(/[\\\/\?\*\[\]:]/g, "_");

      // Excel sheet名称长度限制为31个字符
      if (safeSheetName.length > 31) {
        safeSheetName = safeSheetName.substring(0, 31);
      }

      // 确保工作表名称唯一
      let finalSheetName = safeSheetName;
      let counter = 1;
      while (usedSheetNames.has(finalSheetName)) {
        // 如果名称已存在，添加数字后缀
        const suffix = `_${counter}`;
        const maxLength = 31 - suffix.length;
        finalSheetName = safeSheetName.substring(0, maxLength) + suffix;
        counter++;
      }

      usedSheetNames.add(finalSheetName);

      // 添加工作表到工作簿
      XLSX.utils.book_append_sheet(workbook, worksheet, finalSheetName);

      console.log(
        `${goodsName}: ${emails.length} 个邮箱 -> Sheet: ${finalSheetName}`
      );
    }

    // 保存Excel文件
    XLSX.writeFile(workbook, outputFile);
    console.log(`\nExcel文件已保存: ${outputFile}`);

    // 最终结果统计
    console.log(`\n=== 最终验证结果 ===`);
    console.log(`原始记录总数: ${jsonData.length}`);
    console.log(`有效记录数: ${emailGoodsMap.length}`);
    console.log(`基础验证通过: ${uniqueBasicEmails.length}`);
    console.log(`深度验证通过: ${finalValidEmails.length}`);
    console.log(`深度验证失败: ${deepInvalidEmails.length}`);
    console.log(`商品类型数量: ${sortedGoodsNames.length}`);

    // 显示每个商品的邮箱数量（按数量排序显示）
    console.log("\n各商品邮箱数量统计（按数量排序）:");
    for (const goodsName of sortedGoodsNames) {
      console.log(`${goodsName}: ${groupedByGoods[goodsName].length} 个邮箱`);
    }
  } catch (error) {
    console.error("处理文件时出错:", error.message);
  }
}

// 运行脚本
processEmailFile()
  .then(() => {
    console.log("\n脚本执行完成！");
  })
  .catch((error) => {
    console.error("脚本执行失败:", error);
  });
